package com.atguigu.day19.reference03;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.Supplier;

/*
Lambda: 简化函数式接口生成的匿名内部类
各种引用: 简化Lambda表达式
  引用的分类:
        方法引用  数组引用  构造器引用
  前提: 重写方法的方法体只有一行代码
  方法引用:
      形式:
         类名::静态方法名    重写方法的形参 与类调用静态方法的实参一一匹配
         对象名::实例方法名  重写方法的形参 与对象调用方法的实参一一匹配
         类名::实例方法名    重写的方法 只有一个形参 且 是方法的调用者
                           重写的方法 有多个形参第一个是方法的调用者 后续是方法的实参



 */
public class MethodReference {
    @Test
    public void test07(){
     //todo 类名::实例方法名  重写的方法 有多个形参第一个是方法的调用者 后续是方法的实参
        //匿名内部类
     /*   D d = new D() {
            @Override
            public String dConcat(String a, String b) {
                return a.concat(b);
            }
        };*/
        //lambda
       // D d = (a,b)->a.concat(b);
        //方法引用
        D d = String::concat;

        String result = d.dConcat("安琪拉*", "米莱迪");
        System.out.println("result = " + result);

    }


    @Test
    public void test06(){
        //todo   类名::实例方法名    重写的方法 只有一个形参 且 是方法的调用者
        //匿名内部类
      /*  C c  = new C() {
            @Override
            public int getLength(String s) {
                return s.length();
            }
        };*/
        //lambda
        //C c = s-> s.length();
        //方法引用
        C c = String::length;



        int length = c.getLength("安琪拉plus");
        System.out.println("length = " + length);

    }


    @Test
    public void test05(){
        //todo 对象名::实例方法名  重写方法的形参 与对象调用方法的实参一一匹配
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三","李四","王五","赵六");

/*    匿名内部类
        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/
        //lambda
        //list.forEach(s-> System.out.println(s));
        //方法引用
        list.forEach(System.out::println);

    }


    @Test
    public void test04(){
        //todo 对象名::实例方法名  重写方法的形参 与对象调用方法的实参一一匹配
        Person p = new Person();
        //匿名内部类
     /*   B b = new B() {
            @Override
            public void b(int m, int n) {
                p.show(m,n);
            }
        };*/
        //lambda
      //  B b = (m,n)->p.show(m,n);
        //引用
        B b = p::show;

        b.b(33,66);

    }


    @Test
    public void test03(){
        //todo 对象名::实例方法名  重写方法的形参 与对象调用方法的实参一一匹配
        Person p = new Person();
        p.name="李白";
        //匿名内部类
      /*  Supplier<String> s = new Supplier<String>() {
            @Override
            public String get() {
                return p.getName();
            }
        };*/
        //lambda
       // Supplier<String> s=()->p.getName();
        //引用
        Supplier<String> s=p::getName;

        String value = s.get();
        System.out.println("value = " + value);


    }




    @Test
    public void test02(){
        //todo 类名::静态方法名    重写方法的形参 与类调用静态方法的实参一一匹配

        //匿名内部类
     /*   A a = new A() {
            @Override
            public int getSum(int m, int n) {
                return Integer.sum(m,n);
            }
        };*/
        //lambda
     //   A a = (m,n)-> Integer.sum(m,n);
        //引用

        A a = Integer::sum;

        int sum = a.getSum(33, 66);
        System.out.println("sum = " + sum);

    }


    @Test
    public void test01(){
        //todo 类名::静态方法名    重写方法的形参 与类调用静态方法的实参一一匹配
        //匿名内部类
    /*    Supplier<Double> s = new Supplier<Double>() {
            @Override
            public Double get() {
                return Math.random();
            }
        };*/
        //lambda
      //  Supplier<Double> s = ()->Math.random();
        //引用
        Supplier<Double> s =Math::random;


        Double value = s.get();
        System.out.println("value = " + value);

    }
}
